package com.yidu.action;

import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.yidu.common.JsonMsg;
import com.yidu.common.Pages;
import com.yidu.common.Tools;
import com.yidu.domain.ListenAuditing;
import com.yidu.domain.ListenBackstageUser;
import com.yidu.domain.ListenFinance;
import com.yidu.domain.ListenFinanceDetail;
import com.yidu.domain.ListenPurchase;
import com.yidu.domain.ListenSell;
import com.yidu.domain.ListenSellDetail;
import com.yidu.domain.ListenStock;
import com.yidu.domain.ListenStockRecord;
import com.yidu.service.ListenAuditingService;
import com.yidu.service.ListenFinanceDetailService;
import com.yidu.service.ListenFinanceService;
import com.yidu.service.ListenPurchaseService;
import com.yidu.service.ListenSellDetailService;
import com.yidu.service.ListenSellService;
import com.yidu.service.ListenStockRecordService;
import com.yidu.service.ListenStockService;
 
/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author wujie
 * @since 2018-11-27
 */
@Controller
@RequestMapping("/listenSell")
public class ListenSellController {
	/**
	 * 注入销售service服务类
	 */
	@Resource
	private ListenSellService listenSellService;

	/**
	 * 注入销售明细service服务类
	 */
	@Resource
	private ListenSellDetailService listenSellDetailService;

	/**
	 * 注入库存service服务类
	 */
	@Resource
	private ListenStockService listenStockService;
	
	
	/**
	 * 注入库存记录service服务类
	 */
	@Resource
	private ListenStockRecordService recordService;

	/**
	 * 注入分公司采购service服务类
	 */
	@Resource
	private ListenPurchaseService listenPurchaseService;
	
	/**
	 * 注入财务service服务类
	 */
	@Resource
	private ListenFinanceService  financeService;
	
	
	/**
	 * 注入财务service服务类
	 */
	@Resource
	private ListenFinanceDetailService detailService;
	
	@Resource
	ListenAuditingService auditingService ;
	
	@Resource
	ListenPurchaseService  purchaseService;

	/**
	 * 查询销售记录
	 * 
	 * @param listenSell
	 *            销售类对象
	 * @return
	 */
	@RequestMapping("selectAll")
	@ResponseBody
	public Map<String, Object> selectAll(ListenSell listenSell) {
		// 获取map集合
		Map<String, Object> map = new HashMap<>();
		// 判断销售订单ID是否为空
		if (!Tools.isEmpty(listenSell.getSellId())) {
			// 给map集合赋值
			map.put("sellId", listenSell.getSellId());
		}
		// 判断操作人是否为空
		if (!Tools.isEmpty(listenSell.getOper())) {
			// 给map集合赋值
			map.put("oper", listenSell.getOper());
		}
		// 判断销售对象是否为空
		if (!Tools.isEmpty(listenSell.getSellTarget())) {
			// 给map集合赋值
			map.put("sellTarget", listenSell.getSellTarget());
		}
		// 判断开始时间是否为空
		if (listenSell.getStartTime() != null && !"".equals(listenSell.getStartTime())) {
			// 给map集合赋值
			map.put("startTime", listenSell.getStartTime() + " 00:00:00");
		}
		// 判断结束时间是否为空
		if (listenSell.getEndTime() != null && !"".equals(listenSell.getEndTime())) {
			// 给map集合赋值
			map.put("endTime", listenSell.getEndTime() + " 23:59:59");
		}
		// 如果page不为空
		if (listenSell.getPage() != null && listenSell.getLimit() != null) {
			// 创建一个page对象
			Pages page = new Pages();
			// 给curPage赋值
			page.setCurPage(listenSell.getPage());
			// 给MaxResult赋值
			page.setMaxResult(listenSell.getLimit());
			// 添加到Map集合中
			map.put("firstRows", page.getFirstRows());
			map.put("maxResult", page.getMaxResult());
		}

		// 查询所有的到一个销售集合
		List<ListenSell> list = listenSellService.selectAll(map);
		// 查询总行数
		int rows = listenSellService.selectAllCount(map);

		// 得到一个新的map集合
		Map<String, Object> layuiMap = new HashMap<>();
		// 给map集合赋值
		layuiMap.put("code", 0);
		layuiMap.put("msg", "");
		layuiMap.put("count", rows);
		layuiMap.put("data", list);
		// 返回到前台页面
		return layuiMap;
	}

	/**
	 * 查询销售审核
	 * 
	 * @param listenSell
	 *            销售类对象
	 * @return
	 */
	@RequestMapping("selectState")
	@ResponseBody
	public Map<String, Object> selectState(ListenSell listenSell) {
		// 得到一个map集合
		Map<String, Object> map = new HashMap<>();
		//如果id不为空
		if (!Tools.isEmpty(listenSell.getSellId())) {
			// 给map集合赋值
			map.put("sellId", listenSell.getSellId());
		}
		//如果操作人不为空
		if (!Tools.isEmpty(listenSell.getOper())) {
			// 给map集合赋值
			map.put("oper", listenSell.getOper());
		}
		//如果销售对象不为空
		if (!Tools.isEmpty(listenSell.getSellTarget())) {
			// 给map集合赋值
			map.put("sellTarget", listenSell.getSellTarget());
		}
		//如果开始时间不为空
		if (listenSell.getStartTime() != null && !"".equals(listenSell.getStartTime())) {
			// 给map集合赋值
			map.put("startTime", listenSell.getStartTime() + " 00:00:00");
		}
		//如果结束时间不为空
		if (listenSell.getEndTime() != null && !"".equals(listenSell.getEndTime())) {
			// 给map集合赋值
			map.put("endTime", listenSell.getEndTime() + " 23:59:59");
		}
		// 如果page不为空
		if (listenSell.getPage() != null && listenSell.getLimit() != null) {
			//创建一个page对象
			Pages page = new Pages();
			//给CurPage赋值
			page.setCurPage(listenSell.getPage());
			//给MaxResult赋值
			page.setMaxResult(listenSell.getLimit());
			//添加到map集合中
			map.put("firstRows", page.getFirstRows());
			map.put("maxResult", page.getMaxResult());
		}
		//根据map集合查询的到一个list集合
		List<ListenSell> list = listenSellService.selectState(map);
		//根据map查询的到总行数
		int rows = listenSellService.selectAllStateCount(map);
		//创建一个layuiMap对象
		Map<String, Object> layuiMap = new HashMap<>();
		//赋值给layuiMap集合
		layuiMap.put("code", 0);
		layuiMap.put("msg", "");
		layuiMap.put("count", rows);
		layuiMap.put("data", list);
		//返回到前台页面
		return layuiMap;
	}

	/**
	 * 查询总经理审核
	 * 
	 * @param listenSell
	 * @return
	 */
	@RequestMapping("selectManager")
	@ResponseBody
	public Map<String, Object> selectManager(ListenSell listenSell) {
		//创建一个map集合
		Map<String, Object> map = new HashMap<>();
		//如果id不为空
		if (!Tools.isEmpty(listenSell.getSellId())) {
			// 给map集合赋值
			map.put("sellId", listenSell.getSellId());
		}
		//如果操作人不为空
		if (!Tools.isEmpty(listenSell.getOper())) {
			// 给map集合赋值
			map.put("oper", listenSell.getOper());
		}
		//如果销售对象不为空
		if (!Tools.isEmpty(listenSell.getSellTarget())) {
			// 给map集合赋值
			map.put("sellTarget", listenSell.getSellTarget());
		}
		//如果开始时间不为空
		if (listenSell.getStartTime() != null && !"".equals(listenSell.getStartTime())) {
			// 给map集合赋值
			map.put("startTime", listenSell.getStartTime() + " 00:00:00");
		}
		//如果结束时间不为空
		if (listenSell.getEndTime() != null && !"".equals(listenSell.getEndTime())) {
			// 给map集合赋值
			map.put("endTime", listenSell.getEndTime() + " 23:59:59");
		}
		// 如果page不为空
		if (listenSell.getPage() != null && listenSell.getLimit() != null) {
			//创建一个page对象
			Pages page = new Pages();
			//给CurPage赋值
			page.setCurPage(listenSell.getPage());
			//给MaxResult赋值
			page.setMaxResult(listenSell.getLimit());
			//添加到map集合中
			map.put("firstRows", page.getFirstRows());
			map.put("maxResult", page.getMaxResult());
		}
		
		List<ListenSell> list = listenSellService.selectManager(map);
		int rows = listenSellService.selectManagerCount(map);

		Map<String, Object> layuiMap = new HashMap<>();

		layuiMap.put("code", 0);
		layuiMap.put("msg", "");
		layuiMap.put("count", rows);
		layuiMap.put("data", list);
		return layuiMap;
	}
	/**
	 * 总公司财务增加库存减少
	 * 
	 * @param listenSell
	 */
	public void MinusStockAddMoney(ListenSell listenSell, HttpSession session) {
		// 通过销售ID查询的到一个List集合
		List<ListenSellDetail> list = listenSellDetailService.findByDetails(listenSell.getSellId());
		// 得到session，获取当前登录的用户对象
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		// 遍历List集合得到销售明细对象
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			ListenSellDetail listenSellDetail = (ListenSellDetail) iterator.next();
			// 创建一个库存对象
			ListenStock stock = new ListenStock();
			// 给库存商品ID赋值
			if (listenSellDetail.getMuId() != null && !"".equals(listenSellDetail.getMuId())) {
				stock.setMuId(listenSellDetail.getMuId());
			}
			// 给库存公司ID赋值
			stock.setCompanyId("1");
			// 给库存数量赋值
			stock.setStockNumber(listenSellDetail.getMuNumber());
			//根据公司ID和乐器ID修改库存
			listenSellService.updateMinusNumber(stock);
			//根据公司ID和乐器ID查询库存
			List<ListenStock> stockList = listenStockService.findById(stock);
			//遍历库存集合
			for (ListenStock listenStock : stockList) {
				// 将库存对象传入修改方法
				if(!stockList.isEmpty()) {
					//创建一个库存记录record对象
					ListenStockRecord record = new ListenStockRecord();
					//生成随机数ID赋值
					record.setSrId(Tools.getRandomString(32));
					//赋值给record对象中的stockId
					record.setStockId(listenStock.getStockId());
					//赋值给record乐器名称
					record.setMuName(listenSellDetail.getMuName());
					//将当前时间赋值给记录时间
					record.setSrTime(new Date());
					//将当前时间赋值给操作时间
					record.setOpenTime(new Date());
					//将库存出入数量赋值给记录数量
					record.setSrNumber(listenSellDetail.getMuNumber());
					//赋值给操作说明
					record.setSrExplain("总公司销售，出库");
					//赋值是否可见
					record.setIsva(1);
					//赋值操作人
					record.setOper(user.getBuName());
					//添加一条库存记录
					recordService.insertSelective(record);
				}else {//如果库存表没有公司库存
					//将生成的随机数赋值给库存id
					stock.setStockId(Tools.getRandomString(32));
					//设置是否可见
					stock.setIsva(1);
					//赋值操作人
					stock.setOper(user.getBuName());
					//赋值操作时间
					stock.setOpenTime(new Date());
					//添加一个公司库存
					listenSellService.addStock(stock);
					//创建一个库存记录record对象
					ListenStockRecord record = new ListenStockRecord();
					//生成随机数ID赋值
					record.setSrId(Tools.getRandomString(32));
					//赋值给record对象中的stockId
					record.setStockId(listenStock.getStockId());
					//赋值给record乐器名称
					record.setMuName(listenSellDetail.getMuName());
					//将当前时间赋值给记录时间
					record.setSrTime(new Date());
					//将当前时间赋值给操作时间
					record.setOpenTime(new Date());
					//将库存出入数量赋值给记录数量
					record.setSrNumber(listenSellDetail.getMuNumber());
					//赋值给操作说明
					record.setSrExplain("总公司销售，出库");
					//赋值是否可见
					record.setIsva(1);
					//赋值操作人
					record.setOper(user.getBuName());
					//添加一条库存记录
					recordService.insertSelective(record);
				}
			}
			// 得到财务对象
			ListenFinance finance = new ListenFinance();
			// 给财务公司Id赋值
			finance.setCompanyId("1");
			// 给财务公司金额赋值
			finance.setCompanyPrice(listenSellDetail.getSubtotal());
			// 将财务对象传入修改方法
			listenSellService.updateAddMoney(finance);
			//创建一个财务明细对象
		}
			ListenFinanceDetail detail = new ListenFinanceDetail();
			ListenSell sell = listenSellService.findBySellId(listenSell.getSellId());
			//赋值财务明细ID
			detail.setFdId(Tools.getRandomString(32));
			//赋值财务ID
			detail.setFinanceId("1");
			//赋值交易记录时间
			detail.setFdTime(new Date());
			//赋值操作时间
			detail.setOpenTime(new Date());
			//赋值交易金额
			detail.setFdPrice(sell.getSellPrice());
			//赋值业务ID
			detail.setVocationalWorkId(listenSell.getSellId());
			//赋值交易数量
			detail.setFdNumber(sell.getSellNumber());
			//设置是否可见
			detail.setIsva(1);
			//赋值操作人
			detail.setOper(user.getBuName());
			//赋值交易说明
			detail.setSort("收入，总公司销售");
			//添加到财务明细表
			detailService.insertDetail(detail);
	}
	/**
	 * 修改审核状态
	 * 
	 * @param listenSell
	 *            销售类对象
	 * @return
	 */
	@RequestMapping("updateState")
	@ResponseBody
	public JsonMsg updateState(ListenSell listenSell, HttpSession session) {
		//得到session对象
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		//赋值给操作人
		listenSell.setOper(user.getBuName());
		// 修改订单对象
		int rows = listenSellService.updateState(listenSell);
		//根据销售ID查询
		ListenSell sell = listenSellService.findBySellId(listenSell.getSellId());
		// 得到Json
		JsonMsg msg = new JsonMsg();
		//如果修改成功
		if (rows > 0) {
			//创建一个采购订单对象
			ListenPurchase purchase = new ListenPurchase();
			//赋值采购订单ID
			purchase.setPurchaseId(sell.getSort());
			//赋值采购状态
			purchase.setAuditingStatus(6);
			//修改采购状态
			listenPurchaseService.updateState(purchase);
			//创建一个审核记录对象
			ListenAuditing auditing = new ListenAuditing();
			//生产随机ID赋值给审核记录ID
			auditing.setAuditingId(Tools.getRandomString(32));
			//赋值业务ID
			auditing.setVocationalWorkId(listenSell.getSellId());
			//赋值审核状态
			auditing.setAuditingStatus(listenSell.getSellState());
			//赋值审核说明
			auditing.setAuditingExplain("通过");
			//赋值审核时间
			auditing.setAuditingTime(new Date());
			//赋值审核人
			auditing.setAuditingPeople(user.getBuName());
			//设置是否可见
			auditing.setIsva(1);
			//赋值操作时间
			auditing.setOpenTime(new Date());
			//赋值操作人
			auditing.setOper(user.getBuName());
			//赋值审核部门
			auditing.setAuditingDepartment("总公司总经理");
			//赋值审核订单
			auditing.setAuditingOrder("总公司销售订单");
			//添加到审核记录表
			auditingService.sellInsert(auditing);
			// 添加分公司库存减少财务
//			AddStockMinusMoney(listenSell,session);
			// 总公司财务增加库存减少
			MinusStockAddMoney(listenSell, session);
			
			// 给Json赋值
			msg.setMsg("审核成功");
			msg.setDatas(0);
		} else {
			// 给Json赋值
			msg.setMsg("修改失败");
			msg.setDatas(1);
		}
		// 返回json到前台页面
		return msg;
	}

	/**
	 * 修改审核状态
	 * 
	 * @param listenSell
	 *            销售类对象
	 * @return
	 */
	@RequestMapping("updateStateses")
	@ResponseBody
	public JsonMsg updateStateses(ListenSell listenSell, HttpSession session) {
		//得到session对象
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		//赋值给操作人
		listenSell.setOper(user.getBuName());
		// 修改订单对象
		int rows = listenSellService.updateState(listenSell);
		// 得到Json
		JsonMsg msg = new JsonMsg();
		if (rows > 0) {
			//创建一个审核记录对象
			ListenAuditing auditing = new ListenAuditing();
			//生产随机ID赋值给审核记录ID
			auditing.setAuditingId(Tools.getRandomString(32));
			//赋值业务ID
			auditing.setVocationalWorkId(listenSell.getSellId());
			//赋值审核状态
			auditing.setAuditingStatus(listenSell.getSellState());
			//赋值审核说明
			auditing.setAuditingExplain("通过");
			//赋值审核时间
			auditing.setAuditingTime(new Date());
			//赋值审核人
			auditing.setAuditingPeople(user.getBuName());
			//设置是否可见
			auditing.setIsva(1);
			//赋值操作时间
			auditing.setOpenTime(new Date());
			//赋值操作人
			auditing.setOper(user.getBuName());
			//赋值审核部门
			auditing.setAuditingDepartment("总公司财务");
			//赋值审核订单
			auditing.setAuditingOrder("总公司销售订单");
			//添加到审核记录表
			auditingService.sellInsert(auditing);
			// 给Json赋值
			msg.setMsg("审核成功");
			msg.setDatas(0);
		} else {
			//创建一个审核记录对象
			ListenAuditing auditing = new ListenAuditing();
			//生产随机ID赋值给审核记录ID
			auditing.setAuditingId(Tools.getRandomString(32));
			//赋值业务ID
			auditing.setVocationalWorkId(listenSell.getSellId());
			//赋值审核状态
			auditing.setAuditingStatus(listenSell.getSellState());
			//赋值审核说明
			auditing.setAuditingExplain("不通过");
			//赋值审核时间
			auditing.setAuditingTime(new Date());
			//赋值审核人
			auditing.setAuditingPeople(user.getBuName());
			//设置是否可见
			auditing.setIsva(1);
			//赋值操作时间
			auditing.setOpenTime(new Date());
			//赋值操作人
			auditing.setOper(user.getBuName());
			//赋值审核部门
			auditing.setAuditingDepartment("总公司财务");
			//赋值审核订单
			auditing.setAuditingOrder("总公司销售订单");
			//添加到审核记录表
			auditingService.sellInsert(auditing);
			// 给Json赋值
			msg.setMsg("修改失败");
			msg.setDatas(1);
		}
		// 返回json到前台页面
		return msg;
	}

	/**
	 * 修改审核状态
	 * 
	 * @param listenSell
	 * @return JsonMsg
	 */
	@RequestMapping("updateStates")
	@ResponseBody
	public JsonMsg updateStates(ListenPurchase purchase, ListenSell listenSell, HttpSession session) {
		/**
		 * 返回值
		 */
		int rows = 0;
		int rowss = 0;
		// 通过销售ID查询的到一个List集合
		List<ListenSellDetail> list = listenSellDetailService.findByDetails(listenSell.getSellId());
		// 修改订单对象
		if (listenSell.getSellState() == 4) {
			//给采购对象赋值状态
			purchase.setAuditingStatus(4);
			//给采购对象赋值ID
			purchase.setPurchaseId(listenSell.getPurchaseId());
			rowss = listenPurchaseService.updateState(purchase);
			//得到session对象
			ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
			//赋值给操作人
			listenSell.setOper(user.getBuName());
			//修改订单状态
			rows = listenSellService.updateState(listenSell);
			//rowss和rows>0
			if (rowss > 0 && rows > 0) {
				//创建一个sell对象
				ListenSell listenSells = new ListenSell();
				//赋值是否可见
				listenSells.setIsva(0);
				//赋值sellID
				listenSells.setSellId(listenSell.getSellId());
				//根据销售订单修改数据
				listenSellService.update(listenSells);
				//创建一个审核记录对象
				ListenAuditing auditing = new ListenAuditing();
				//生产随机ID赋值给审核记录ID
				auditing.setAuditingId(Tools.getRandomString(32));
				//赋值业务ID
				auditing.setVocationalWorkId(listenSell.getSellId());
				//赋值审核状态
				auditing.setAuditingStatus(listenSell.getSellState());
				//赋值审核说明
				auditing.setAuditingExplain("未通过");
				//赋值审核时间
				auditing.setAuditingTime(new Date());
				//赋值审核人
				auditing.setAuditingPeople(user.getBuName());
				//设置是否可见
				auditing.setIsva(1);
				//赋值操作时间
				auditing.setOpenTime(new Date());
				//赋值操作人
				auditing.setOper(user.getBuName());
				//赋值审核部门
				auditing.setAuditingDepartment("总公司");
				//赋值审核订单
				auditing.setAuditingOrder("总公司销售订单");
				//添加到审核记录表
				auditingService.sellInsert(auditing);
			}
		} else {
			//得到session对象
			ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
			//赋值给操作人
			listenSell.setOper(user.getBuName());
			//修改订单状态
			rows = listenSellService.updateState(listenSell);
		}
		// 得到Json
		JsonMsg msg = new JsonMsg();
		//如果修改成功
		if (rows > 0) {
			// 给Json赋值
			msg.setMsg("审核成功");
			msg.setDatas(0);
		} else {
			ListenBackstageUser users = (ListenBackstageUser) session.getAttribute("user");
			//创建一个审核记录对象
			ListenAuditing auditing = new ListenAuditing();
			//生产随机ID赋值给审核记录ID
			auditing.setAuditingId(Tools.getRandomString(32));
			//赋值业务ID
			auditing.setVocationalWorkId(listenSell.getSellId());
			//赋值审核状态
			auditing.setAuditingStatus(listenSell.getSellState());
			//赋值审核说明
			auditing.setAuditingExplain("通过");
			//赋值审核时间
			auditing.setAuditingTime(new Date());
			//赋值审核人
			auditing.setAuditingPeople(users.getBuName());
			//设置是否可见
			auditing.setIsva(1);
			//赋值操作时间
			auditing.setOpenTime(new Date());
			//赋值操作人
			auditing.setOper(users.getBuName());
			//赋值审核部门
			auditing.setAuditingDepartment("总公司");
			//赋值审核订单
			auditing.setAuditingOrder("总公司销售订单");
			//添加到审核记录表
			auditingService.sellInsert(auditing);
			
			// 给Json赋值
			msg.setMsg("修改失败");
			msg.setDatas(1);
		}
		// 返回json到前台页面
		return msg;
	}

	/**
	 * 查询库存是否足够
	 * 
	 * @param listenSell
	 * @return
	 */
	@RequestMapping("findByMusical")
	@ResponseBody
	public JsonMsg findByMusical(ListenSell listenSell) {
		// 定义一个数量
		int muNumber = 0;
		// 定义一个库存数量
		int stockNumber = 0;
		// 得到一个Json
		JsonMsg msg = new JsonMsg();
		// 根据销售ID查询得到一个List集合
		List<ListenSell> list = listenSellService.findByMusicalNumber(listenSell.getSellId());
		// 遍历List集合得到一个销售对象
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			ListenSell listenSells = (ListenSell) iterator.next();
			// 给定义的数量赋值
			muNumber = listenSells.getMuNumber();
			// 给定义的库存数量赋值
			stockNumber = listenSells.getStockNumber();
			// 如果商品数量大于库存数量
			if (muNumber > stockNumber) {
				// 给json赋值
				msg.setDatas(0);
				msg.setMsg("有一个或多个商品库存不足！");
				// 返回json到页面上
				return msg;
			} else {	
				// 给json赋值
				msg.setDatas(1);
				msg.setMsg("库存足够");
				// 返回json到页面上
				return msg;
			}
		}
		return null;
	}
}